package com.ruoyi.user.service.impl;

import java.util.List;
import java.util.Date;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.Objects;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.SecurityUtils;
import org.springframework.transaction.annotation.Transactional;
import com.ruoyi.matchmaker.domain.TbMatchmaker;
import com.ruoyi.user.mapper.TbUserMapper;
import com.ruoyi.user.domain.TbUser;
import com.ruoyi.user.service.ITbUserService;

/**
 * 管理用户Service业务层处理
 *
 * @author ruoyi
 * @date 2025-07-29
 */
@Service
public class TbUserServiceImpl extends ServiceImpl<TbUserMapper, TbUser> implements ITbUserService
{
    @Autowired
    private TbUserMapper tbUserMapper;

    /**
     * 查询管理用户
     *
     * @param userId 管理用户主键
     * @return 管理用户
     */
    @Override
    public TbUser selectTbUserByUserId(Long userId)
    {
        return tbUserMapper.selectTbUserByUserId(userId);
    }

    /**
     * 查询管理用户列表
     *
     * @param tbUser 管理用户
     * @return 管理用户
     */
    @Override
    public List<TbUser> selectTbUserList(TbUser tbUser)
    {
        return tbUserMapper.selectTbUserList(tbUser);
    }

    /**
     * 新增管理用户
     *
     * @param tbUser 管理用户
     * @return 结果
     */
    @Transactional
    @Override
    public int insertTbUser(TbUser tbUser)
    {
        // 设置默认值
        Date now = new Date();

        // 密码加密
        if (StringUtils.isNotEmpty(tbUser.getPassword())) {
            tbUser.setPassword(SecurityUtils.encryptPassword(tbUser.getPassword()));
        }

        // 设置默认值
        if (tbUser.getFan() == null) {
            tbUser.setFan(0L);
        }
        if (tbUser.getCountFollow() == null) {
            tbUser.setCountFollow(0L);
        }
        if (tbUser.getCountLike() == null) {
            tbUser.setCountLike(0L);
        }
        if (tbUser.getAccountStatus() == null) {
            tbUser.setAccountStatus(1); // 默认账号状态为正常
        }
        if (tbUser.getIsVerified() == null) {
            tbUser.setIsVerified(1); // 默认已实名认证
        }
        if (tbUser.getIsVip() == null) {
            tbUser.setIsVip(0); // 默认非VIP
        }

        // 设置时间
        if (tbUser.getRegisterTime() == null) {
            tbUser.setRegisterTime(now);
        }
        if (tbUser.getCreatedAt() == null) {
            tbUser.setCreatedAt(now);
        }

        int rows = tbUserMapper.insertTbUser(tbUser);
        insertTbMatchmaker(tbUser);
        return rows;
    }

    /**
     * 修改管理用户
     *
     * @param tbUser 管理用户
     * @return 结果
     */
    @Transactional
    @Override
    public int updateTbUser(TbUser tbUser)
    {
        // 查询原始数据进行比较
        TbUser originalUser = tbUserMapper.selectTbUserByUserId(tbUser.getUserId());
        boolean dataChanged = false;

        // 如果密码不为空，进行加密
        if (StringUtils.isNotEmpty(tbUser.getPassword())) {
            tbUser.setPassword(SecurityUtils.encryptPassword(tbUser.getPassword()));
            dataChanged = true; // 密码修改算作数据变化
        }

        // 检查用户基本信息是否发生变化
        if (originalUser != null) {
            if (!Objects.equals(originalUser.getPhone(), tbUser.getPhone()) ||
                !Objects.equals(originalUser.getNickname(), tbUser.getNickname()) ||
                !Objects.equals(originalUser.getGender(), tbUser.getGender()) ||
                !Objects.equals(originalUser.getBirthDate(), tbUser.getBirthDate()) ||
                !Objects.equals(originalUser.getAvatarUrl(), tbUser.getAvatarUrl()) ||
                !Objects.equals(originalUser.getFan(), tbUser.getFan()) ||
                !Objects.equals(originalUser.getCountFollow(), tbUser.getCountFollow()) ||
                !Objects.equals(originalUser.getCountLike(), tbUser.getCountLike()) ||
                !Objects.equals(originalUser.getUserRole(), tbUser.getUserRole()) ||
                !Objects.equals(originalUser.getRegisterSource(), tbUser.getRegisterSource()) ||
                !Objects.equals(originalUser.getOpenId(), tbUser.getOpenId()) ||
                !Objects.equals(originalUser.getRegisterTime(), tbUser.getRegisterTime()) ||
                !Objects.equals(originalUser.getLastLoginTime(), tbUser.getLastLoginTime()) ||
                !Objects.equals(originalUser.getLastLoginIp(), tbUser.getLastLoginIp()) ||
                !Objects.equals(originalUser.getAccountStatus(), tbUser.getAccountStatus()) ||
                !Objects.equals(originalUser.getIsVerified(), tbUser.getIsVerified()) ||
                !Objects.equals(originalUser.getIsVip(), tbUser.getIsVip()) ||
                !Objects.equals(originalUser.getVipExpireTime(), tbUser.getVipExpireTime())) {
                dataChanged = true;
            }

            // 检查红娘信息是否发生变化
            if (tbUser.getTbMatchmakerList() != null && !tbUser.getTbMatchmakerList().isEmpty()) {
                List<TbMatchmaker> originalMatchmakers = originalUser.getTbMatchmakerList();
                List<TbMatchmaker> newMatchmakers = tbUser.getTbMatchmakerList();

                if (originalMatchmakers == null || originalMatchmakers.isEmpty()) {
                    dataChanged = true; // 新增红娘信息
                } else if (originalMatchmakers.size() != newMatchmakers.size()) {
                    dataChanged = true; // 红娘信息数量变化
                } else {
                    // 比较红娘信息内容
                    for (int i = 0; i < originalMatchmakers.size(); i++) {
                        TbMatchmaker original = originalMatchmakers.get(i);
                        TbMatchmaker updated = newMatchmakers.get(i);

                        if (!Objects.equals(original.getRealName(), updated.getRealName()) ||
                            !Objects.equals(original.getIdCardNo(), updated.getIdCardNo()) ||
                            !Objects.equals(original.getPhone(), updated.getPhone()) ||
                            !Objects.equals(original.getMatchmakerLevel(), updated.getMatchmakerLevel()) ||
                            !Objects.equals(original.getServiceArea(), updated.getServiceArea()) ||
                            !Objects.equals(original.getServiceYears(), updated.getServiceYears()) ||
                            !Objects.equals(original.getIntroduction(), updated.getIntroduction()) ||
                            !Objects.equals(original.getCertification(), updated.getCertification()) ||
                            !Objects.equals(original.getMatchmakerStatus(), updated.getMatchmakerStatus())) {
                            dataChanged = true;
                            break;
                        }
                    }
                }
            }
        }

        // 只有数据发生变化时才设置更新时间
        if (dataChanged) {
            tbUser.setUpdatedAt(new Date());
        }

        tbUserMapper.deleteTbMatchmakerByUserId(tbUser.getUserId());
        insertTbMatchmaker(tbUser);
        return tbUserMapper.updateTbUser(tbUser);
    }

    /**
     * 批量删除管理用户
     *
     * @param userIds 需要删除的管理用户主键
     * @return 结果
     */
    @Transactional
    @Override
    public int deleteTbUserByUserIds(Long[] userIds)
    {
        tbUserMapper.deleteTbMatchmakerByUserIds(userIds);
        return tbUserMapper.deleteTbUserByUserIds(userIds);
    }

    /**
     * 删除管理用户信息
     *
     * @param userId 管理用户主键
     * @return 结果
     */
    @Transactional
    @Override
    public int deleteTbUserByUserId(Long userId)
    {
        tbUserMapper.deleteTbMatchmakerByUserId(userId);
        return tbUserMapper.deleteTbUserByUserId(userId);
    }

    /**
     * 新增红娘信息信息
     *
     * @param tbUser 管理用户对象
     */
    public void insertTbMatchmaker(TbUser tbUser)
    {
        List<TbMatchmaker> tbMatchmakerList = tbUser.getTbMatchmakerList();
        Long userId = tbUser.getUserId();
        if (StringUtils.isNotNull(tbMatchmakerList))
        {
            List<TbMatchmaker> list = new ArrayList<TbMatchmaker>();
            Date now = new Date();

            for (TbMatchmaker tbMatchmaker : tbMatchmakerList)
            {
                tbMatchmaker.setUserId(userId);

                // 设置默认值
                if (tbMatchmaker.getSuccessCount() == null) {
                    tbMatchmaker.setSuccessCount(0L);
                }

                // 设置时间
                if (tbMatchmaker.getCreatedAt() == null) {
                    tbMatchmaker.setCreatedAt(now);
                    // 新增时不设置updatedAt
                } else {
                    // 更新时设置updatedAt
                    tbMatchmaker.setUpdatedAt(now);
                }

                list.add(tbMatchmaker);
            }
            if (list.size() > 0)
            {
                tbUserMapper.batchTbMatchmaker(list);
            }
        }
    }

    /**
     * 检查红娘真实姓名是否唯一
     *
     * @param realName 真实姓名
     * @param userId 用户ID（修改时排除自己）
     * @return 结果
     */
    @Override
    public boolean checkMatchmakerRealNameUnique(String realName, Long userId)
    {
        if (StringUtils.isEmpty(realName)) {
            return true;
        }

        TbMatchmaker matchmaker = tbUserMapper.checkMatchmakerRealNameUnique(realName);
        if (StringUtils.isNotNull(matchmaker)) {
            // 如果是新增（userId为null），只要找到记录就不唯一
            // 如果是修改，只有当找到的记录不是当前用户时才不唯一
            if (userId == null || !matchmaker.getUserId().equals(userId)) {
                return false; // 不唯一
            }
        }
        return true; // 唯一
    }

    /**
     * 检查红娘身份证号是否唯一
     *
     * @param idCardNo 身份证号
     * @param userId 用户ID（修改时排除自己）
     * @return 结果
     */
    @Override
    public boolean checkMatchmakerIdCardUnique(String idCardNo, Long userId)
    {
        if (StringUtils.isEmpty(idCardNo)) {
            return true;
        }

        TbMatchmaker matchmaker = tbUserMapper.checkMatchmakerIdCardUnique(idCardNo);
        if (StringUtils.isNotNull(matchmaker)) {
            // 如果是新增（userId为null），只要找到记录就不唯一
            // 如果是修改，只有当找到的记录不是当前用户时才不唯一
            if (userId == null || !matchmaker.getUserId().equals(userId)) {
                return false; // 不唯一
            }
        }
        return true; // 唯一
    }

    /**
     * 检查红娘联系电话是否唯一
     *
     * @param phone 联系电话
     * @param userId 用户ID（修改时排除自己）
     * @return 结果
     */
    @Override
    public boolean checkMatchmakerPhoneUnique(String phone, Long userId)
    {
        if (StringUtils.isEmpty(phone)) {
            return true;
        }

        TbMatchmaker matchmaker = tbUserMapper.checkMatchmakerPhoneUnique(phone);
        if (StringUtils.isNotNull(matchmaker)) {
            // 如果是新增（userId为null），只要找到记录就不唯一
            // 如果是修改，只有当找到的记录不是当前用户时才不唯一
            if (userId == null || !matchmaker.getUserId().equals(userId)) {
                return false; // 不唯一
            }
        }
        return true; // 唯一
    }

    /**
     * 检查用户手机号是否唯一
     *
     * @param phone 手机号
     * @param userId 用户ID（修改时排除自己）
     * @return 结果
     */
    @Override
    public boolean checkUserPhoneUnique(String phone, Long userId)
    {
        if (StringUtils.isEmpty(phone)) {
            return true;
        }

        TbUser user = tbUserMapper.checkUserPhoneUnique(phone);
        if (StringUtils.isNotNull(user)) {
            // 如果是新增（userId为null），只要找到记录就不唯一
            // 如果是修改，只有当找到的记录不是当前用户时才不唯一
            if (userId == null || !user.getUserId().equals(userId)) {
                return false; // 不唯一
            }
        }
        return true; // 唯一
    }

    /**
     * 检查用户昵称是否唯一
     *
     * @param nickname 昵称
     * @param userId 用户ID（修改时排除自己）
     * @return 结果
     */
    @Override
    public boolean checkUserNicknameUnique(String nickname, Long userId)
    {
        if (StringUtils.isEmpty(nickname)) {
            return true;
        }

        TbUser user = tbUserMapper.checkUserNicknameUnique(nickname);
        if (StringUtils.isNotNull(user)) {
            // 如果是新增（userId为null），只要找到记录就不唯一
            // 如果是修改，只有当找到的记录不是当前用户时才不唯一
            if (userId == null || !user.getUserId().equals(userId)) {
                return false; // 不唯一
            }
        }
        return true; // 唯一
    }

    /**
     * 检查用户第三方平台ID是否唯一
     *
     * @param openId 第三方平台ID
     * @param userId 用户ID（修改时排除自己）
     * @return 结果
     */
    @Override
    public boolean checkUserOpenIdUnique(String openId, Long userId)
    {
        if (StringUtils.isEmpty(openId)) {
            return true;
        }

        TbUser user = tbUserMapper.checkUserOpenIdUnique(openId);
        if (StringUtils.isNotNull(user)) {
            // 如果是新增（userId为null），只要找到记录就不唯一
            // 如果是修改，只有当找到的记录不是当前用户时才不唯一
            if (userId == null || !user.getUserId().equals(userId)) {
                return false; // 不唯一
            }
        }
        return true; // 唯一
    }
}
